import { id_split } from '../../../../../../components/my_schedule/DataDefine/sourceData';
import { listenCssVar_mana } from '../../../../../element/css/Func/listenCssVar/classes/cla_listenCssVar_mana';
import { create_ListenEvent_mana } from '../../../../../element/Event/listenEvent_mana';
// eslint-disable-next-line no-unused-vars
import { unit_listenEvent_mana } from '../../../../../element/Event/listenEvent_mana/Classes/cla_unit_listenEvent_mana';
import { seekElement_attribute } from '../../../../../Func/uniFunc/Func/getTargetEl';
import { toStringTypeCheck } from '../../../../../Func/uniFunc/Func/toStringTypeCheck';
import { dragList_dataMana_body } from '../../cla_dragList_dataMana_body';
import { DL_curElement_attribute } from '../DataDefine/sourceData';
import { getOrCreate_floatDomEl } from '../Func/getOrCreate_floatDomEl';
import { dragList_eventBind } from './cla_dragList_eventBind';

const vDragList_data_manaTag = 'vDragList_data_mana';

class vDragList_data_mana {
  get [Symbol.toStringTag]() {
    return vDragList_data_manaTag;
  }

  /**
   *
   * @param {HTMLElement} element
   */
  constructor(element, idPrefix, attriKey, direct = 'vertical') {
    this.targetEl = element;
    this.idPrefix = idPrefix;
    this.attriKey = attriKey;
    this.direct = direct;

    // 事件 管理
    this.eventMana = create_ListenEvent_mana(element.id);

    // 给元素 添加 cssvar 变量管理
    this.cssvarObj = new listenCssVar_mana(element);

    this.body_AttriMana.dragLisT_floatDomEl = this.dragLisT_floatEl;
  }

  /**
   * 目标绑定的 主体元素
   * @type {HTMLElement}
   */
  targetEl;

  /**
   * 元素 消失 的 方向
   * @type {'vertical' | 'level' | 'both'}
   */
  direct;

  /**
   * 中间 过渡元素
   * @type {HTMLElement}
   */
  dragLisT_floatEl = getOrCreate_floatDomEl();

  /**
   * body元素 的 attribute 管理
   * @type {dragList_dataMana_body}
   *
   */
  body_AttriMana = new dragList_dataMana_body();

  /**
   * 目标元素 数组
   * @type {Array}
   */
  targetData;

  /**
   * 执行动画 后 需 操作
   * @type {function}
   */
  afterCb;

  /**
   * 设置 targetData 信息
   * clone virtualData 复制 信息
   * @param {array} targetArr
   */
  initTargetData(targetArr) {
    this.targetData = targetArr;
    this.virtualData = [...this.targetData];
  }

  /**
   * 用于 处理的 临时 数组
   * @type {Array}
   */
  virtualData;

  /**
   * id 前缀
   */
  idPrefix;

  /**
   * 元素 attribute key 值 名称
   */
  attriKey;

  /**
   * 当前 移入 元素
   */
  #curToEl;

  /**
   * 设置 当前 移入元素
   * @param {HTMLElement} element
   */
  setCurToNode(element) {
    this.#lastToEl = this.#curToEl;
    this.#curToEl = element;
  }

  /**
   * 上一个 移入 元素
   */
  #lastToEl;

  /**
   * 判定 移入 元素 是否 相同
   * @returns {Boolean}
   */
  isSameToNode() {
    // if (this.#curToEl == this.#lastToEl) {
    //   console.log(this.#curToEl);
    // }
    return this.#curToEl == this.#lastToEl;
  }

  /**
   * 特定 注入 this 绑定事件
   * @type {dragList_eventBind}
   */
  eventBind = new dragList_eventBind();

  /**
   * event 的 管理 集
   * @type {unit_listenEvent_mana}
   */
  eventMana;

  /**
   * 设置 css 的 mana
   * @type {listenCssVar_mana}
   */
  cssvarObj;

  /**
   * 添加到 virtualData 将要添加的元素 添加 在锚定元素 前后
   * @param {number} toInd 锚定 元素
   * @param {Array} extendArr 添加 的元素
   * @param {boolean} isbefore 放置 之前 或 之后 默认 之后
   */
  virtual_addto(locateKeyVal, extendArr, isbefore = false) {
    if (toStringTypeCheck(extendArr, 'string')) {
      extendArr = [extendArr];
    }
    let toInd = this.getKeyValInd(locateKeyVal);
    this.virtualData.splice(toInd + (isbefore ? 0 : 1), 0, ...extendArr);
  }

  /**
   * 删除 virtualData 中 的 数组
   * @param {Array} deleteArr 待 删除的 数组
   */
  virtual_remove(deleteArr) {
    let ret = [];
    if (toStringTypeCheck(deleteArr, 'string')) {
      deleteArr = [deleteArr];
    }
    let curKeyValInd;

    let _remove = (ind) => {
      this.virtualData.splice(ind, 1);
    };

    for (const keyVal of deleteArr) {
      curKeyValInd = this.getKeyValInd(keyVal);
      if (curKeyValInd > -1) {
        ret.push(keyVal);
        _remove(curKeyValInd);
      }
    }
    return ret;
  }

  /**
   * 更定 删除 元素 的位置 添加 在锚定元素 前后
   * @param {string} locateKeyVal 锚定元素 keyVal 值
   * @param {array} deleteArr 要删除 的 数组
   * @param {boolean} isbefore 是否 将 删除的 元素 放置 之前
   */
  changeKeyValIndexCb(locateKeyVal, deleteArr, isbefore = false) {
    let deletedArr = this.virtual_remove(deleteArr);
    this.virtual_addto(locateKeyVal, deletedArr, isbefore);
    // console.log(this.virtualData);
  }

  /**
   * 验证 当前 targetEl 是否 指定 keyVal 值 的 元素
   * @param {MouseEvent} event
   */
  is_unitKeyEl(event) {
    let el = seekElement_attribute(event.target, this.attriKey);

    return el == null ? false : true;
  }

  /**
   * 获取 当前 virtualData key 值 的 index
   * @param {string} keyVal key 值
   * @returns
   */
  getKeyValInd(keyVal) {
    return this.virtualData.indexOf(keyVal);
  }

  /**
   * 根据 前缀 :a 和 key 值 :b 获取 a + b
   * 会根据 这个 提供 确定 id 值 -- 自定义 cb
   * @param {string} keyVal key 值 关键字
   * @returns
   */
  getKeyVal_id(keyVal) {
    return this.idPrefix + id_split + keyVal;
  }

  /**
   * 获取 对应 key 值 的 元素 根据 keyVal 的 id document 上 查找 element
   * @param {string} keyVal key 值 关键字
   * @returns
   */
  getKeyVal_el(keyVal) {
    return document.getElementById(this.getKeyVal_id(keyVal));
  }

  /**
   * 获取 keyVal 数组 的 元素
   * @param {Array} keyValArr keyVal 数组
   * @returns
   */
  getKeyValArr_el(keyValArr) {
    let ret = [];
    for (const keyVal of keyValArr) {
      let el = this.getKeyVal_el(keyVal);
      if (el != null) {
        ret.push(el);
      }
    }
    return ret;
  }

  /**
   * 获取 event.target 的 attrikey 元素
   * @param {HTMLElement} element event.target
   * @returns
   */
  getEventTarget_element(element) {
    return seekElement_attribute(element, this.attriKey);
  }

  /**
   * 根据 event.target 元素 上溯 查询 含有指定名称 属性 的元素 的 对应值
   * 会根据 element 返回 对应值 -- 自定义 cb
   * @param {HTMLElement} element event.target
   * @returns {string|undefined}
   */
  getEventTarget_keyVal(element) {
    let locateAttributeEl = this.getEventTarget_element(element);
    if (locateAttributeEl != null) {
      return locateAttributeEl.getAttribute(this.attriKey);
    }
  }

  /**
   * 获取 event.target 的 spacename
   * @param {HTMLElement} element
   * @returns {string} 元素 的 spacename
   */
  getEventTarget_spacename(element) {
    let spacenameEl = seekElement_attribute(
      element,
      DL_curElement_attribute.spacename
    );
    return spacenameEl.getAttribute(DL_curElement_attribute.spacename);
  }

  /**
   * 获取点击元素 的 spacename
   * @param {HTMLElement} element
   */
  spacenameCb(element) {
    let dragListCurEl = seekElement_attribute(
      element,
      DL_curElement_attribute.spacename
    );
    let curValue = dragListCurEl.getAttribute(
      DL_curElement_attribute.spacename
    );
    return curValue;
  }

  /**
   * 将 数据 引入 到 实际 对象中
   */
  impactToTruethData() {
    this.targetData.splice(0, this.targetData.length, ...this.virtualData);
  }

  /**
   * 基础 判定 from to space 为 相同目录
   * @returns {boolean}
   */
  analysisFromToEl() {
    // 基础 判定 from to space 为 相同目录
    if (this.body_AttriMana.dragFrom == this.body_AttriMana.dragTo) {
      return true;
    }
    return false;
  }
}

export { vDragList_data_mana };
